package container

import (
	"bytes"
	"fmt"
	"reflect"
)

type GBSet struct {
	mapValue map[interface{}]bool
}

// 创建新对象 - 从值初始化
func GBNewSet(values ...interface{}) * GBSet {
	// 分配 map 格式数据
	mapValueBuild := make(map[interface{}]bool, 0)
	// 从值初始化
	for _, v := range values {
		mapValueBuild[v] = true
	}
	// 分配对象
	return &GBSet {
		mapValue:   mapValueBuild,
	}
}

// 创建新对象 - 从自动推导初始化
func GBNewSetFromAuto(valueSource interface{}) * GBSet {
	// 分配 map 格式数据
	mapValueBuild := make(map[interface{}]bool, 0)
	// 反射值，尝试识别类型
	argsValue := reflect.ValueOf(valueSource)
	// 目前只识别以下类型
	if argsValue.Kind() == reflect.Slice || argsValue.Kind() == reflect.Array {
		// 取得长度
		count := argsValue.Len()
		// 保存所有
		for i := 0; i < count; i ++ {
			// 当前值
			v := argsValue.Index(i)
			// 添加保存
			mapValueBuild[v.Interface()] = true
		}
	}
	// 分配对象
	return &GBSet {
		mapValue:   mapValueBuild,
	}
}

// 打印
func (obj * GBSet) String() string {
	if obj == nil || obj.mapValue == nil {
		return ""
	}
	return fmt.Sprintf("set[%v]", obj.Join(" "))
}

// 拼接成字符串
func (obj * GBSet) Join(sep string) string {
	var i = 0
	var buff bytes.Buffer
	for k := range obj.mapValue {
		buff.WriteString(fmt.Sprint(k))
		if i < len(obj.mapValue) - 1 {
			buff.WriteString(sep)
		}
		i ++
	}
	return buff.String()
}

// 克隆新对象
func (obj * GBSet) Clone() * GBSet {
	result := &GBSet {
		mapValue:make(map[interface{}]bool, 0),
	}
	for k, v := range obj.mapValue {
		result.mapValue[k] = v
	}
	return result
}

// 遍历
func (obj * GBSet) ForEach(fcb func(interface{})) {
	for k := range obj.mapValue {
		fcb(k)
	}
}

// 是否空
func (obj * GBSet) Empty() bool {
	return len(obj.mapValue) == 0
}

// 总数
func (obj * GBSet) Count() int {
	return len(obj.mapValue)
}

// 是否包含
func (obj * GBSet) Contains(value interface{}) bool {
	_, ok := obj.mapValue[value]
	return ok
}

// 是否包含任意
func (obj * GBSet) ContainsAny(values ...interface{}) bool {
	for _, v := range values {
		if _, ok := obj.mapValue[v]; ok {
			return true
		}
	}
	return false
}

// 是否包含所有
func (obj * GBSet) ContainsAll(values ...interface{}) bool {
	for _, v := range values {
		if _, ok := obj.mapValue[v]; ok {
			continue
		}
		return false
	}
	return true
}

// 添加
func (obj * GBSet) Add(values ...interface{}) {
	for _, v := range values {
		obj.mapValue[v] = true
	}
}

// 删除
func (obj * GBSet) Remove(values ...interface{}) {
	for _, v := range values {
		delete(obj.mapValue, v)
	}
}

// 并集
func (obj * GBSet) Union(sets ... * GBSet) * GBSet {
	result := obj.Clone()
	for _, set := range sets {
		for k := range set.mapValue {
			result.mapValue[k] = true
		}
	}
	return result
}

// 差集
func (obj * GBSet) Difference(sets ... * GBSet) * GBSet {
	result := obj.Clone()
	for _, set := range sets {
		for k := range set.mapValue {
			if _, ok := obj.mapValue[k]; ok {
				delete(result.mapValue, k)
			}
		}
	}
	return result
}

// 交集
func (obj * GBSet) Intersect(sets ... * GBSet) * GBSet {
	result := obj.Clone()
	for _, set := range sets {
		for k := range obj.mapValue {
			if _, ok := set.mapValue[k]; ok {
				continue
			} else {
				delete(result.mapValue, k)
			}
		}
	}
	return result
}

// 补集
func (obj * GBSet) Complement(full * GBSet) * GBSet {
	result := GBNewSet()
	for k := range full.mapValue {
		if _, ok := obj.mapValue[k]; ok {
			continue
		} else {
			result.Add(k)
		}
	}
	return result
}
